package com.interview.rpc.client;

import com.interview.rpc.protocol.Response;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;

/**
 * RPC客户端处理器
 * 
 * 处理从服务器返回的响应数据
 */
public class RpcClientHandler extends ChannelInboundHandlerAdapter {
    
    // 存储正在进行的请求
    private ConcurrentHashMap<String, CompletableFuture<Response>> pendingRequests;
    
    public RpcClientHandler(ConcurrentHashMap<String, CompletableFuture<Response>> pendingRequests) {
        this.pendingRequests = pendingRequests;
    }
    
    /**
     * 处理接收到的数据
     * 
     * @param ctx ChannelHandlerContext对象
     * @param msg 接收到的数据，在这里应该是Response对象
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 将接收到的数据转换为Response对象
        Response response = (Response) msg;
        
        // 根据响应中的请求ID获取对应的CompletableFuture对象
        CompletableFuture<Response> future = pendingRequests.remove(response.getRequestId());
        if (future != null) {
            // 完成CompletableFuture，将响应数据传入
            future.complete(response);
        }
    }
    
    /**
     * 处理异常
     * 
     * @param ctx ChannelHandlerContext对象
     * @param cause 异常对象
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 打印异常堆栈信息
        cause.printStackTrace();
        // 关闭与服务器的连接
        ctx.close();
    }
}